Add some CFG manipulation tools for IRCode by tkf · Pull Request #45305 · JuliaLang/julia

tkf · 2022-05-13T11:58:25Z

This PR adds CFG manipulation function allocate_new_blocks! and a derived function allocate_gotoifnot_sequence! to help CFG manipulation of IRCodes.

julia/base/compiler/ssair/ir.jl

Lines 1630 to 1680 in 90133d4

    
               allocate_new_blocks!(ir::IRCode, statement_positions) -> info::NewBlocksInfo 
        
           Create new "singleton" basic blocks (i.e., it contains a single instruction) 
        
           before `statement_positions`.  This function adds `2 * length(statement_positions)` 
        
           blocks; i.e., `length(statement_positions)` blocks for the new singleton basic 
        
           blocks and the remaining `length(statement_positions)` blocks for the basic 
        
           block containing the instructions starting at each `statement_positions`. 
        
           The caller must ensure that: 
        
               @assert issorted(statement_positions) 
        
               @assert all(1 <= p <= length(ir.stmts) for p in statement_positions) 
        
           Note that this function does not wire up the CFG for newly created BBs. It just 
        
           inserts the dummy `GotoNode(0)` at the end of the new singleton BBs and the BB 
        
           _before_ (in terms of `ir.cfg.bocks`) it.  The predecessors of the BB just 
        
           before the newly added singleton BB and the successors of the BB just after the 
        
           newly added singleton BB are re-wired.  See `allocate_gotoifnot_sequence!` for 
        
           an example for creating a valid CFG. 
        
           For example, given an `ir` containing: 
        
               #bb 
        
                   %1 = instruction_1 
        
                   %2 = instruction_2 
        
           `allocate_new_blocks!(ir, [2])` produces 
        
               #bb′ 
        
                   %1 = instruction_1 
        
                   goto #0               # dummy 
        
               #new_bb_1 
        
                   goto #0               # dummy 
        
               #new_bb_2 
        
                   %2 = instruction_2 
        
           The predecessors of `#bb′` are equivalent to the predecessors of `#bb`.  The successors of 
        
           `#new_bb_2` are equivalent to the successors of `#bb`. 
        
           The returned object `info` can be passed to `foreach_allocated_new_block` for 
        
           iterating over allocated basic blocks.  An indexable object `info.ssachangemap` 
        
           can be used for mapping old SSA values to the new locations. 
        
           Properties of `info::NewBlocksInfo`: 
        
           * `target_blocks`: A list of original IDs of the basic blocks in which new blocks are 
        
             inserted; i.e., the basic blocks containing instructions `statement_positions`. 
        
           * `ssachangemap`: Given an original statement position `iold`, the new statement position is 
        
             `ssachangemap[iold]`. 
        
           * `bbchangemap`: Given an original basic block id `iold`, the new basic block ID is 
        
             `bbchangemap[iold]`.

julia/base/compiler/ssair/ir.jl

Lines 1937 to 1959 in 90133d4

    
               allocate_gotoifnot_sequence!(ir::IRCode, statement_positions) -> info::NewBlocksInfo 
        
           Insert a new basic block before each `statement_positions` and a `GotoIfNot` 
        
           that jumps over the newly added BB.  Unlike `allocate_new_blocks!`, this 
        
           function results in an IR with valid CFG. 
        
           Read `allocate_new_blocks!` on the preconditions on `statement_positions`. 
        
           For example, given an `ir` containing: 
        
               #bb 
        
                   %1 = instruction_1 
        
                   %2 = instruction_2 
        
           `allocate_new_blocks!(ir, [2])` produces 
        
               #bb′ 
        
                   %1 = instruction_1 
        
                   goto #new_bb_2 if not false 
        
               #new_bb_1                          # this bb is unreachable 
        
                   goto #new_bb_2 
        
               #new_bb_2 
        
                   %2 = instruction_2

This PR also adds a bit more somewhat automated way to wrap Core.Compiler interface functions as Base interface functions; e.g.,

julia/base/compilerwrappers.jl

Lines 17 to 18 in 90133d4

    
           for T in [:IRCode, :InstructionStream, :Instruction, :StmtRange, :UseRef] 
        
               @eval getindex(xs::Core.Compiler.$T, args...) = Core.Compiler.getindex(xs, args...)

Some of the manually-handled definitions in IRShow are now handled this way. These definitions are very handy for writing tests and also playing with them in REPL. But I think this PR can be done without them if it's better to do this elsewhere.

vtjnash · 2022-05-13T15:44:59Z

I don't know this code well, so @aviatesk or @ianatol should probably review

tkf · 2022-05-13T15:59:10Z

It looks like the tester_win32 failure is OOM #44948
https://build.julialang.org/#/builders/42/builds/5170

ianatol

SGTM in terms of code quality, though I don't quite understand the use case. Could you explain a bit more when we would want to use allocate_new_blocks! and allocate_gotoifnot_sequence!?

base/compiler/ssair/ir.jl

vchuravy · 2022-05-13T21:55:07Z

So I think in the LICM PR I wanted to split an edge. Can you add a test for this?

a:
  br %cond, #b, #d
b: 
  ; insertion-point
  br %cond2, #c, #d
c:
  br #b
d:
  ret

Goal:

a:
  br %cond, #new, #d
new:
  br #b
b: 
  br %cond2, #c, #d
c:
  br #b
d:
  ret

Also if you add comments to the test explaining what transformation is happening it would be easier to think through if we cover all test cases.

Keno · 2022-05-16T03:36:20Z

I like the general direction of this. In the past I had suggested we make a stdlib for this, but I'm fine with putting it in Base for now and making code movement decisions later. In general, it would be good to have a relatively clean and stable API for IRCode. Various utilities exist in various packages, so consolidating them is a good idea.

Co-authored-by: Ian Atol <ian.atol@juliacomputing.com>

oscardssmith · 2022-05-16T13:39:06Z

IMO, this PR would make more sense if there was a second commit in it that makes more of the compiler to use these tools.

base/compiler/ssair/ir.jl

aviatesk · 2022-05-17T02:52:31Z

base/compiler/ssair/ir.jl

+Create new "singleton" basic blocks (i.e., it contains a single instruction)
+before `statement_positions`.  This function adds `2 * length(statement_positions)`
+blocks; i.e., `length(statement_positions)` blocks for the new singleton basic
+blocks and the remaining `length(statement_positions)` blocks for the basic
+block containing the instructions starting at each `statement_positions`.


Suggested change

Create new "singleton" basic blocks (i.e., it contains a single instruction)

before `statement_positions`. This function adds `2 * length(statement_positions)`

blocks; i.e., `length(statement_positions)` blocks for the new singleton basic

blocks and the remaining `length(statement_positions)` blocks for the basic

block containing the instructions starting at each `statement_positions`.

Create new "singleton" basic blocks (i.e., it contains a single dummy instruction)

before `statement_positions`. This function adds `2 * length(statement_positions)`

instructions; i.e., `length(statement_positions)` instructions for the new singleton basic

blocks and the remaining `length(statement_positions)` instructions for the basic

block containing the dummy instructions starting at each `statement_positions`.

explains better?

I tried to pull some ideas from this. I also cleaned up the API which simplified the explanation.

base/compiler/ssair/ir.jl

aviatesk · 2022-05-17T03:25:00Z

Thanks, these tools look very useful and the code quality is great.

IMO, this PR would make more sense if there was a second commit in it that makes more of the compiler to use these tools.

I'm not sure that there are such places where we manipulate CFG of IRCode currently. The purpose of this PR is to land the tools for CFG manipulation first so that we can do experiment optimizations involving CFG transformation in the future without inventing these tools.

Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>

tkf · 2022-05-19T12:58:58Z

So I think in the LICM PR I wanted to split an edge. Can you add a test for this?

@vchuravy I created a sketch for how to do LICM https://nbviewer.org/gist/tkf/d4734be24d2694a3afd669f8f50e6b0f/00_notebook.ipynb (see the last example). It's tedious to create the input IR "by hand" so I want to do this after #45306 if we are to add it to the test.

@ianatol Does this also answer your question about when we would want to use these APIs? Another example was for doing the lowering of modifyfield! at IRCode-level https://github.com/tkf/julia/blob/518569a70ccfc14894c698cba3aabcb907eaedba/base/compiler/ssair/atomics.jl#L459-L492 which is how I initially prototyped this API. This is probably not the right direction for modifyfield! lowering but I think it is a good realistic example.

if you add comments to the test explaining what transformation is happening

There are single-sentence explanations in the testset labels. I also added some pseudocode for explaining the input and output IRs.

base/compiler/ssair/ir.jl

vchuravy · 2023-10-31T01:02:42Z

Okay rebased onto ToT, and I am in the process of rewriting #36832 on top of this.

DilumAluthge · 2026-02-21T07:01:15Z

@vchuravy Just checking in on the status of this PR, because it hasn't had any activity for a while. Can I close this PR, or would you like to keep it open?

vchuravy · 2026-02-23T09:30:08Z

Please keep it open.

Add some CFG manipulation tools

90133d4

tkf force-pushed the cfg-tools branch from 097a869 to 90133d4 Compare May 13, 2022 12:00

vchuravy requested a review from vtjnash May 13, 2022 12:17

tkf mentioned this pull request May 13, 2022

Add code_ircode #45306

Merged

vtjnash requested review from aviatesk and ianatol May 13, 2022 15:40

ianatol reviewed May 13, 2022

View reviewed changes

base/compiler/ssair/ir.jl Outdated Show resolved Hide resolved

base/compiler/ssair/ir.jl Outdated Show resolved Hide resolved

base/compiler/ssair/ir.jl Show resolved Hide resolved

vchuravy requested review from Keno and yhls and removed request for vtjnash May 13, 2022 21:55

tkf and others added 2 commits May 16, 2022 14:41

Check statement_positions early

6da85a2

Co-authored-by: Ian Atol <ian.atol@juliacomputing.com>

Manually handle SSAValue outside ssamap

2c428ef

aviatesk reviewed May 17, 2022

View reviewed changes

tkf and others added 10 commits May 17, 2022 12:41

Use link in docstring

345f455

Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>

Simplify bbchangemap and gotolabelchangemap

b43f98e

Type assertion for avoiding dynamic dispatch

71c1d05

Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>

Explicitly specify the number of new blocks

1752762

Merge branch 'master' into cfg-tools

ab52887

Let ssamap handle SSAValue

855a2a1

Merge branch 'cfg-tools' of github.com:tkf/julia into cfg-tools

cd2347c

Improve/fix docstrings

ce879ad

Fix tests for 32-bit

a23139e

Explain input and output IRs

0307ced

Merge branch 'master' into cfg-tools

8764ab3

vchuravy reviewed Oct 29, 2023

View reviewed changes

base/compiler/ssair/ir.jl Outdated Show resolved Hide resolved

vchuravy added 6 commits October 30, 2023 16:25

Merge remote-tracking branch 'origin/master' into cfg-tools

788934e

fixup! Merge remote-tracking branch 'origin/master' into cfg-tools

d3cb286

use NoCallInfo instead of nothing

2454482

use core_ircode instead of custom utility

2d37c14

fixup! use core_ircode instead of custom utility

6cc67a8

mark test as broken

6319865

vchuravy requested review from aviatesk and topolarity and removed request for yhls October 31, 2023 00:18

vchuravy added the compiler:optimizer Optimization passes (mostly in base/compiler/ssair/) label Oct 31, 2023

vchuravy self-assigned this Oct 31, 2023

vchuravy mentioned this pull request Oct 31, 2023

add LoopInfo + LICM #36832

Open

3 tasks

Merge remote-tracking branch 'origin/master' into cfg-tools

86c5ef0

vchuravy mentioned this pull request Nov 30, 2024

Forward-mode AD chalk-lab/Mooncake.jl#389

Merged

11 tasks

	allocate_new_blocks!(ir::IRCode, statement_positions) -> info::NewBlocksInfo

	Create new "singleton" basic blocks (i.e., it contains a single instruction)
	before `statement_positions`. This function adds `2 * length(statement_positions)`
	blocks; i.e., `length(statement_positions)` blocks for the new singleton basic
	blocks and the remaining `length(statement_positions)` blocks for the basic
	block containing the instructions starting at each `statement_positions`.

	The caller must ensure that:

	@assert issorted(statement_positions)
	@assert all(1 <= p <= length(ir.stmts) for p in statement_positions)

	Note that this function does not wire up the CFG for newly created BBs. It just
	inserts the dummy `GotoNode(0)` at the end of the new singleton BBs and the BB
	_before_ (in terms of `ir.cfg.bocks`) it. The predecessors of the BB just
	before the newly added singleton BB and the successors of the BB just after the
	newly added singleton BB are re-wired. See `allocate_gotoifnot_sequence!` for
	an example for creating a valid CFG.

	For example, given an `ir` containing:

	#bb
	%1 = instruction_1
	%2 = instruction_2

	`allocate_new_blocks!(ir, [2])` produces

	#bb′
	%1 = instruction_1
	goto #0 # dummy
	#new_bb_1
	goto #0 # dummy
	#new_bb_2
	%2 = instruction_2

	The predecessors of `#bb′` are equivalent to the predecessors of `#bb`. The successors of
	`#new_bb_2` are equivalent to the successors of `#bb`.

	The returned object `info` can be passed to `foreach_allocated_new_block` for
	iterating over allocated basic blocks. An indexable object `info.ssachangemap`
	can be used for mapping old SSA values to the new locations.

	Properties of `info::NewBlocksInfo`:

	* `target_blocks`: A list of original IDs of the basic blocks in which new blocks are
	inserted; i.e., the basic blocks containing instructions `statement_positions`.
	* `ssachangemap`: Given an original statement position `iold`, the new statement position is
	`ssachangemap[iold]`.
	* `bbchangemap`: Given an original basic block id `iold`, the new basic block ID is
	`bbchangemap[iold]`.

	allocate_gotoifnot_sequence!(ir::IRCode, statement_positions) -> info::NewBlocksInfo

	Insert a new basic block before each `statement_positions` and a `GotoIfNot`
	that jumps over the newly added BB. Unlike `allocate_new_blocks!`, this
	function results in an IR with valid CFG.

	Read `allocate_new_blocks!` on the preconditions on `statement_positions`.

	For example, given an `ir` containing:

	#bb
	%1 = instruction_1
	%2 = instruction_2

	`allocate_new_blocks!(ir, [2])` produces

	#bb′
	%1 = instruction_1
	goto #new_bb_2 if not false
	#new_bb_1 # this bb is unreachable
	goto #new_bb_2
	#new_bb_2
	%2 = instruction_2

	for T in [:IRCode, :InstructionStream, :Instruction, :StmtRange, :UseRef]
	@eval getindex(xs::Core.Compiler.$T, args...) = Core.Compiler.getindex(xs, args...)

Uh oh!

Conversation

tkf commented May 13, 2022 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

vtjnash commented May 13, 2022

Uh oh!

tkf commented May 13, 2022

Uh oh!

ianatol left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

vchuravy commented May 13, 2022

Uh oh!

Keno commented May 16, 2022

Uh oh!

oscardssmith commented May 16, 2022

Uh oh!

Uh oh!

aviatesk May 17, 2022

Choose a reason for hiding this comment

Uh oh!

tkf May 19, 2022

Choose a reason for hiding this comment

Uh oh!

Uh oh!

aviatesk commented May 17, 2022

Uh oh!

tkf commented May 19, 2022

Uh oh!

Uh oh!

vchuravy commented Oct 31, 2023 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

DilumAluthge commented Feb 21, 2026

Uh oh!

vchuravy commented Feb 23, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

8 participants

tkf commented May 13, 2022 •

edited

Loading

vchuravy commented Oct 31, 2023 •

edited

Loading